const { Article, User, Course, Category, Chapter } = require('../models');
const { NotFoundError } = require('./errors');
/**
 * 自定义 404 错误类
 */
// class NotFoundError extends Error {
//     constructor(message) {
//         super(message);
//         this.name = 'NotFoundError';
//     }
// }

/**
 * 公共方法：查询当前文章
 */
async function getCategory(req) {
    // 获取文章 ID
    const { id } = req.params;
    // const condition = {
    //     include: [
    //         {
    //             model: Course,
    //             as: 'courses',
    //         },
    //     ]
    // }

    // // 查询当前文章
    // const article = await Category.findByPk(id, condition);
    const article = await Category.findByPk(id);

    // 如果没有找到，就抛出异常
    if (!article) {
        throw new NotFoundError(`ID: ${id}的文章未找到。`)
    }

    return article;
}
/**
 * 公共方法：查询当前文章
 */
async function getArticle(req) {
    // 获取文章 ID
    const { id } = req.params;

    // 查询当前文章
    const article = await Article.findByPk(id);

    // 如果没有找到，就抛出异常
    if (!article) {
        throw new NotFoundError(`ID: ${id}的文章未找到。`)
    }

    return article;
}
/**
 * 公共方法：查询用户
 */
async function getUser(req) {
    // 获取文章 ID
    const { id } = req.params;

    // 查询当前文章
    const user = await User.findByPk(id);

    // 如果没有找到，就抛出异常
    if (!user) {
        throw new NotFoundError(`ID: ${id}的用户未找到。`)
    }

    return user;
}
/**
 * 公共方法：查询课程
 */
async function getCourse(req, condition = {}) {
    console.log("req.params", req.params)
    // 获取文章 ID
    const { id } = req.params;

    // 查询当前文章
    const course = await Course.findByPk(id, condition);

    // 如果没有找到，就抛出异常
    if (!course) {
        throw new NotFoundError(`ID: ${id}的课程未找到。`)
    }

    return course;
}

/**
 * 公共方法：查询当前章节
 */
async function getChapter(req, condition = {}) {
    const { id } = req.params;
    const chapter = await Chapter.findByPk(id, condition);
    if (!chapter) {
        throw new NotFoundError(`ID: ${id}的章节未找到。`)
    }

    return chapter;
}

/**
 * 请求成功
 * @param res
 * @param message
 * @param data
 * @param code
 */
function success(res, message, data = {}, code = 200) {
    res.status(code).json({
        status: true,
        message,
        data
    });
}
/**
 * 请求失败
 * @param res
 * @param error
 */
function failure(res, error) {
    if (error.name === 'SequelizeValidationError') {
        const errors = error.errors.map(e => e.message);
        return res.status(400).json({
            status: false,
            message: '请求参数错误',
            errors
        });
    }

    if (error.name === 'NotFoundError') {
        return res.status(404).json({
            status: false,
            message: '资源不存在',
            errors: [error.message]
        });
    }
    if (error.name === 'BadRequestError') {
        return res.status(400).json({
            status: false,
            message: '请求参数错误',
            errors: [error.message]
        });
    }

    if (error.name === 'UnauthorizedError') {
        return res.status(401).json({
            status: false,
            message: '认证失败',
            errors: [error.message]
        });
    }
    if (error.name === 'JsonWebTokenError') {
        return res.status(401).json({
            status: false,
            message: '认证失败',
            errors: ['您提交的 token 错误。']
        });
    }

    if (error.name === 'TokenExpiredError') {
        return res.status(401).json({
            status: false,
            message: '认证失败',
            errors: ['您的 token 已过期。']
        });
    }


    res.status(500).json({
        status: false,
        message: '服务器错误',
        errors: [error.message]
    });
}
module.exports = {
    NotFoundError,
    getArticle,
    success,
    failure,
    getUser,
    getCourse,
    getCategory,
    getChapter
}
